/**
 * 计时器模块使用示例 (zh-timer.js)
 * 此模块提供计时器、秒表和定时器管理器的中文命名封装
 */

// 支持 CommonJS 和 ES 模块导入
const timerModule = require('../../zh/公共函数/zh-timer.js');
const {
  计时器,
  秒表,
  定时器管理器
} = timerModule || {
  计时器: timerModule.计时器 || timerModule.default,
  秒表: timerModule.秒表,
  定时器管理器: timerModule.定时器管理器
};

// 全局状态管理，用于控制所有示例的执行
const 全局状态 = {
  已停止: false,
  当前示例: null,
  示例超时: null,
  当前定时器: null,
  activeTimers: [], // 跟踪所有活动定时器
  
  // 停止所有执行
    停止所有: function(reason) {
      if (this.已停止) return;
      this.已停止 = true;
      console.log(`\n⚠️  全局停止执行: ${reason || '未知原因'}`);
      if (this.示例超时) clearTimeout(this.示例超时);
      if (this.当前定时器) clearTimeout(this.当前定时器);
      
      // 清理所有跟踪的定时器
      if (this.activeTimers && this.activeTimers.length > 0) {
        this.activeTimers.forEach(timerId => {
          clearTimeout(timerId);
          clearInterval(timerId);
        });
      }
      
      // 强制清理所有可能的定时器
      for (let i = 0; i < 1000; i++) {
        clearTimeout(i);
        clearInterval(i);
      }
      process.exit(0);
    },
  
  // 设置当前示例
  设置当前示例: function(name) {
    this.当前示例 = name;
    console.log(`\n🔄 正在执行: ${name}`);
    
    // 设置示例超时（15秒）
    if (this.示例超时) clearTimeout(this.示例超时);
    this.示例超时 = setTimeout(() => {
      this.停止所有(`示例 "${name}" 执行超时`);
    }, 15000);
  },
  
  // 清除当前示例
  清除当前示例: function() {
    if (this.示例超时) {
      clearTimeout(this.示例超时);
      this.示例超时 = null;
    }
    this.当前示例 = null;
  },
  
  // 检查是否可以继续执行
  可以执行: function() {
    return !this.已停止;
  }
};

// 添加全局安全网 - 2分钟后强制退出
setTimeout(() => {
  if (!全局状态.已停止) {
    全局状态.停止所有('程序执行总时间超过2分钟');
  }
}, 120000);

console.log('=== 计时器模块 (zh-timer.js) 使用示例 ===\n');

// 辅助函数：安全执行回调
function 安全回调(回调, thisArg) {
  return function(...args) {
    if (!全局状态.可以执行()) return;
    try {
      return 回调.apply(thisArg, args);
    } catch (err) {
      console.error('回调执行错误:', err);
    }
  };
}

// 增强版安全延迟，确保定时器被跟踪
function 增强安全延迟(ms) {
  if (!全局状态.可以执行()) {
    return Promise.reject(new Error('执行已停止'));
  }
  return new Promise(resolve => {
    const timer = setTimeout(() => {
      if (全局状态.可以执行()) resolve();
    }, ms);
    // 跟踪这个定时器
    全局状态.activeTimers.push(timer);
    // 自动清理已完成的定时器
    setTimeout(() => {
      const index = 全局状态.activeTimers.indexOf(timer);
      if (index > -1) {
        全局状态.activeTimers.splice(index, 1);
      }
    }, ms + 100);
  });
}

// 辅助函数：延迟执行
function 安全延迟(ms) {
  if (!全局状态.可以执行()) {
    return Promise.reject(new Error('执行已停止'));
  }
  return new Promise(resolve => {
    const timer = setTimeout(() => {
      if (全局状态.可以执行()) resolve();
    }, ms);
    // 保存定时器引用以便可能的清理
    if (全局状态.当前定时器) clearTimeout(全局状态.当前定时器);
    全局状态.当前定时器 = timer;
  });
}

// ===== 1. 基本计时器使用 =====
async function 示例1() {
  if (!全局状态.可以执行()) return;
  全局状态.设置当前示例('基本计时器使用');
  
  try {
    console.log('1. 基本计时器使用:');
    
    // 1.1 创建并启动简单定时器 - 单次执行，无循环
    console.log('创建3秒后执行的定时器...');
    await new Promise(resolve => {
      const 基本定时器 = new 计时器(3000);
      基本定时器.回调(安全回调(() => {
        console.log('✓ 基本定时器执行完成 (3秒后)');
        resolve();
      }));
      基本定时器.开始();
    });
    
    // 1.2 循环定时器 - 明确限制执行次数
    console.log('创建2秒循环定时器，执行3次...');
    await new Promise(resolve => {
      const 链式定时器 = new 计时器(2000, { 循环: true });
      let 执行次数 = 0;
      
      链式定时器.回调(安全回调(() => {
        执行次数++;
        console.log(`✓ 循环定时器执行 (每2秒) - 第${执行次数}次`);
        
        // 严格的终止条件
        if (执行次数 >= 3) {
          链式定时器.停止();
          console.log('✓ 循环定时器已停止');
          resolve();
        }
      })).开始();
    });
    
    // 确保示例完成后清除状态
    全局状态.清除当前示例();
  } catch (error) {
    console.error('示例1执行错误:', error);
    全局状态.停止所有('示例执行异常');
  }
}

// ===== 2. 静态方法创建定时器 =====
async function 示例2() {
  if (!全局状态.可以执行()) return;
  全局状态.设置当前示例('静态方法创建定时器');
  
  try {
    console.log('\n2. 静态方法创建定时器:');
    
    // 2.1 使用静态create方法
    console.log('使用静态create方法创建定时器...');
    await new Promise(resolve => {
      const 静态创建定时器 = 计时器.创建(1500);
      静态创建定时器.回调(安全回调(() => {
        console.log('✓ 静态create方法创建的定时器执行');
        resolve();
      }));
      静态创建定时器.开始();
    });
    
    // 2.2 创建延迟执行器
    console.log('创建延迟1.2秒的执行器...');
    await new Promise(resolve => {
      计时器.延迟(1200, 安全回调(() => {
        console.log('✓ 延迟执行器执行');
        resolve();
      }));
    });
    
    全局状态.清除当前示例();
  } catch (error) {
    console.error('示例2执行错误:', error);
    全局状态.停止所有('示例执行异常');
  }
}

// ===== 3. 倒计时功能 =====
async function 示例3() {
  if (!全局状态.可以执行()) return;
  全局状态.设置当前示例('倒计时功能');
  
  try {
    console.log('\n3. 倒计时功能:');
    
    // 3.1 3秒倒计时示例（减少时间）
    console.log('创建3秒倒计时器...');
    await new Promise(resolve => {
      const 倒计时器 = 计时器.倒计时(3);
      
      倒计时器
        .更新回调(安全回调((剩余秒数) => {
          console.log(`  倒计时: ${剩余秒数}秒`);
        }))
        .完成回调(安全回调(() => {
          console.log('✓ 倒计时完成!');
          resolve();
        }))
        .开始();
    });
    
    全局状态.清除当前示例();
  } catch (error) {
    console.error('示例3执行错误:', error);
    全局状态.停止所有('示例执行异常');
  }
}

// ===== 4. 间隔执行器 =====
async function 示例4() {
  if (!全局状态.可以执行()) return;
  全局状态.设置当前示例('间隔执行器');
  
  try {
    console.log('\n4. 间隔执行器:');
    
    // 4.1 间隔执行器 - 减少执行次数
    console.log('创建每秒执行一次的间隔器，共执行3次...');
    await new Promise(resolve => {
      const 间隔执行器 = 计时器.间隔执行(1000);
      let 执行次数 = 0;
      
      间隔执行器.回调(安全回调(() => {
        执行次数++;
        console.log(`  间隔执行 - 第${执行次数}次`);
        
        // 严格的终止条件
        if (执行次数 >= 3) {
          间隔执行器.停止();
          console.log('✓ 间隔执行器已停止');
          resolve();
        }
      })).开始();
    });
    
    全局状态.清除当前示例();
  } catch (error) {
    console.error('示例4执行错误:', error);
    全局状态.停止所有('示例执行异常');
  }
}

// ===== 5. 定时器控制方法 =====
async function 示例5() {
  if (!全局状态.可以执行()) return;
  全局状态.设置当前示例('定时器控制方法');
  
  try {
    console.log('\n5. 定时器控制方法:');
    
    // 5.1 暂停和继续示例
    console.log('创建可控制定时器示例...');
    await new Promise(resolve => {
      const 可控制定时器 = 计时器.间隔执行(800);
      let 控制计数 = 0;
      let 控制已完成 = false;
      
      可控制定时器.回调(安全回调(() => {
        if (控制已完成) return;
        
        控制计数++;
        console.log(`  可控制定时器 - 第${控制计数}次执行`);
        
        // 第3次执行时暂停
        if (控制计数 === 3 && !控制已完成) {
          console.log('  暂停定时器...');
          可控制定时器.暂停();
          
          // 1秒后继续（减少等待时间）
          setTimeout(安全回调(() => {
            if (控制已完成) return;
            console.log('  继续定时器...');
            可控制定时器.开始();
          }), 1000);
        }
        
        // 第5次执行时停止
        if (控制计数 === 5 && !控制已完成) {
          控制已完成 = true;
          console.log('✓ 可控制定时器完成');
          可控制定时器.停止();
          resolve();
        }
      })).开始();
    });
    
    // 5.2 重置功能示例 - 简化逻辑，避免重置后出现问题
    console.log('\n5.2 重置功能示例:');
    await new Promise(resolve => {
      // 不使用重置功能，而是重新创建一个定时器
      console.log('创建一个新的定时器（不使用重置功能）...');
      
      let 阶段 = 0;
      let 阶段1计数 = 0;
      let 阶段2计数 = 0;
      let 阶段已完成 = false;
      
      // 第一阶段定时器
      const 阶段1定时器 = new 计时器(1000, { 循环: true });
      阶段1定时器.回调(安全回调(() => {
        if (阶段已完成) return;
        
        阶段1计数++;
        console.log(`  第一阶段 - 第${阶段1计数}次执行`);
        
        // 执行2次后进入第二阶段
        if (阶段1计数 >= 2 && !阶段已完成) {
          阶段1定时器.停止();
          console.log('  进入第二阶段...');
          阶段 = 1;
          
          // 第二阶段定时器
          const 阶段2定时器 = new 计时器(1000, { 循环: true });
          阶段2定时器.回调(安全回调(() => {
            if (阶段已完成) return;
            
            阶段2计数++;
            console.log(`  第二阶段 - 第${阶段2计数}次执行`);
            
            // 执行3次后完成
            if (阶段2计数 >= 3 && !阶段已完成) {
              阶段已完成 = true;
              阶段2定时器.停止();
              console.log('✓ 重置功能示例完成');
              resolve();
            }
          })).开始();
        }
      })).开始();
    });
    
    全局状态.清除当前示例();
  } catch (error) {
    console.error('示例5执行错误:', error);
    全局状态.停止所有('示例执行异常');
  }
}

// ===== 6. 秒表功能 =====
async function 示例6() {
  if (!全局状态.可以执行()) return;
  全局状态.设置当前示例('秒表功能');
  
  try {
    console.log('\n6. 秒表功能:');
    
    // 6.1 基本秒表使用 - 简化流程
    const 基本秒表 = new 秒表();
    console.log('  开始秒表...');
    基本秒表.开始();
    
    // 1秒后计次（减少时间）
    await 安全延迟(1000);
    const 计次1 = 基本秒表.计次();
    console.log(`  计次1: ${计次1.toFixed(2)}ms`);
    
    // 再过1秒后停止
    await 安全延迟(1000);
    基本秒表.停止();
    const 总时间 = 基本秒表.获取经过时间();
    console.log(`  停止秒表，总时间: ${总时间.toFixed(2)}ms`);
    console.log(`  计次记录:`, 基本秒表.获取计次记录().map(t => t.toFixed(2) + 'ms'));
    console.log('✓ 秒表使用完成');
    
    全局状态.清除当前示例();
  } catch (error) {
    console.error('示例6执行错误:', error);
    全局状态.停止所有('示例执行异常');
  }
}

// ===== 7. 定时器管理器 =====
async function 示例7() {
  if (!全局状态.可以执行()) return;
  全局状态.设置当前示例('定时器管理器');
  
  try {
    console.log('\n7. 定时器管理器:');
    
    // 7.1 创建并管理多个定时器 - 简化管理
    await new Promise(resolve => {
      const 管理器 = new 定时器管理器();
      let 管理器已完成 = false;
      let 间隔计数 = 0;
      
      // 添加单个间隔定时器
      管理器.添加定时器('间隔定时器', 计时器.间隔执行(1000));
      const 间隔定时器 = 管理器.获取定时器('间隔定时器');
      
      间隔定时器.回调(安全回调(() => {
        if (管理器已完成) return;
        
        间隔计数++;
        console.log(`  管理器间隔定时器 - 第${间隔计数}次`);
        
        // 执行3次后完成
        if (间隔计数 >= 3 && !管理器已完成) {
          管理器已完成 = true;
          间隔定时器.停止(); // 直接停止单个定时器，避免使用管理器的停止方法
          console.log('✓ 定时器管理器示例完成');
          resolve();
        }
      }));
      
      // 直接启动定时器
      间隔定时器.开始();
    });
    
    全局状态.清除当前示例();
  } catch (error) {
    console.error('示例7执行错误:', error);
    全局状态.停止所有('示例执行异常');
  }
}

// ===== 8. 实际应用场景 =====
async function 示例8() {
  if (!全局状态.可以执行()) return;
  全局状态.设置当前示例('实际应用场景');
  
  try {
    // 8.1 游戏倒计时示例
    console.log('\n8.1 游戏倒计时示例:');
    await new Promise(resolve => {
      const 游戏倒计时 = 计时器.倒计时(2); // 减少为2秒
      let 游戏示例已完成 = false;
      
      游戏倒计时
        .更新回调(安全回调((秒数) => {
          if (游戏示例已完成) return;
          console.log(`  准备倒计时: ${秒数}...`);
        }))
        .完成回调(安全回调(() => {
          if (游戏示例已完成) return;
          游戏示例已完成 = true;
          console.log('  ✓ 游戏开始!');
          resolve();
        }))
        .开始();
    });
    
    // 8.2 打字效果示例 - 完全避免任何循环风险
    console.log('\n8.2 打字效果示例:');
    await new Promise(resolve => {
      const 文本 = '打字效果演示';
      const 速度 = 200;
      let 索引 = 0;
      let 显示文本 = '';
      let 已完成 = false;
      
      // 使用setTimeout链而不是setInterval，避免循环风险
      function 打印下一个字符() {
        if (!全局状态.可以执行() || 已完成) {
          if (!已完成) {
            已完成 = true;
            console.log(''); // 换行
            console.log('  ⚠️  打字效果已安全终止');
          }
          resolve();
          return;
        }
        
        if (索引 < 文本.length) {
          显示文本 += 文本[索引];
          process.stdout.write('\r  ' + 显示文本);
          索引++;
          
          // 使用setTimeout递归调用，避免setInterval的循环风险
          setTimeout(安全回调(打印下一个字符), 速度);
        } else {
          已完成 = true;
          console.log(''); // 换行
          console.log('  ✓ 打字效果完成');
          resolve();
        }
      }
      
      // 开始打字效果
      打印下一个字符();
      
      // 额外安全保障：文本长度*速度+2秒后强制完成
      setTimeout(安全回调(() => {
        if (!已完成) {
          已完成 = true;
          console.log(''); // 换行
          console.log('  ⚠️  打字效果超时安全终止');
          resolve();
        }
      }), 文本.length * 速度 + 2000);
    });
    
    全局状态.清除当前示例();
  } catch (error) {
    console.error('示例8执行错误:', error);
    全局状态.停止所有('示例执行异常');
  }
}

// 主函数：按顺序执行所有示例
async function 执行所有示例() {
  try {
    await 示例1();
    await 增强安全延迟(500); // 短暂暂停
    
    await 示例2();
    await 增强安全延迟(500);
    
    await 示例3();
    await 增强安全延迟(500);
    
    await 示例4();
    await 增强安全延迟(500);
    
    await 示例5();
    await 增强安全延迟(500);
    
    await 示例6();
    await 增强安全延迟(500);
    
    await 示例7();
    await 增强安全延迟(500);
    
    await 示例8();
    
    // 所有示例完成
    console.log('\n🎉 所有定时器示例执行完成！');
    
    // 立即清理所有定时器并强制退出
    console.log('\n🔒 正在清理所有定时器...');
    // 清理所有跟踪的定时器
    if (全局状态.activeTimers && 全局状态.activeTimers.length > 0) {
      全局状态.activeTimers.forEach(timerId => {
        clearTimeout(timerId);
        clearInterval(timerId);
      });
    }
    // 强制清理所有可能的定时器
    for (let i = 0; i < 1000; i++) {
      clearTimeout(i);
      clearInterval(i);
    }
    // 立即退出，不再等待
    process.exit(0);
  } catch (error) {
    console.error('执行示例时出错:', error);
    process.exit(1);
  }
}

// 启动执行
执行所有示例();